User blog:B1mb0w/J Function Sandpit J 8
'J Function Sandpit \(J_8\)' The J Function is a work in progress. This sandpit defines a notational function called \(J_8\) which contains ideas that will be used in the final J Function. Click here for the J Function blog. 'Summary' Edited: Late Feb 2016 to align to changes to my blog on Fundamental Sequences. The \(J_8\) function is another attempt to create a very fast growing function. It is an algorithm that will be defined using program code to create the notation for a large ordinal up to the size of the Small Veblen Ordinal (SVO). It uses the Unique Ordinal Representation which is defined in another blog. 'Unique Ordinal Representation' It is possible to construct a Unique Ordinal Representation of any ordinal up to SVO using a sequence of finite integers. This can be extended to construct a large number (googolism) in the form: \(f_\gamma^n(p)\) where \(\gamma\) is an ordinal up to SVO, and n, p are finite integers. To illustrate this, lets take the example from the original blog and analyse the structure of the sequence of finite integers \(\) and \( = <,2,4> = <1,2,0,1,0,1,1,1,0,1,0,3,0,2,2,4>\) and finally \( = <,n,p>\) represents a function of the form \(f_\gamma^n(p)\) where \(\gamma\) is represented by a sequence of finite integers: \( = <1,2,0,1,0,1,1,1,0,1,0,3,0,2>\) The sequence \( = <,2,4>\) defines this large number: \(f_{\omega^{\omega} + \omega.3 + 2}^2(4)\) 'Definition of the \(J_8\) function' The \(J_8\) Function uses a very recursive algorithm to define and embed sequences of the form \(\). The rules are as follows: \(q =\) finite integer. \( =\) sequence of the form \(<,,,...,,p,m>\) *where \(0 < p <= q\) and \(0 < m\) *but if: **\(q = 0\) then \( =\) null **\(q = 1\) then \(\) collapses to \(\omega\) \(t =\) finite integer but if \(q = 0\) then \(t =\) null \( =\) sequence of the form \(\) but if \(q = 0\) then \( =\) null \( =\) sequence of the form \(\) but if \(q = 0\) then \( =\) null. \( =\) sequence of the form \(\) but if \(q = 0\) then \(\) collapses to \(a\) a finite integer. 'Some Simple Sequences' Here are some simple sequences and the number they evaluate to: At this point, the \(\) sequence starts to grow and many many large numbers can be generated. The general rule is illustrated as follows: \(n <= p < f_{\gamma}(n+1) = f_{\gamma_a}(n+1)\) therefore the range for p is uniquely defined: Another rule can be explained at this point to illustrate many more examples. The value of \(n\) has a lower bound of: \(Min(2,Max()\) i.e. n may equal the largest finite integer in the sequence \(\) if that number is less than 2. \(Min(2,Max() <= n <= f_{\gamma_a+1}(\gamma_a+2)-1\) and therefore the range for n is uniquely defined: 'Example Sequences' The simple sequences illustrate how to construct a wide range of large numbers using different values of n and p in the sequence \(\). These examples will focus on the sequence \(\) only and will illustrate the construction of various ordinals: Continuing to modify the sequence \(\) will generate these ordinals: The sequence \(\) is bounded and must be less than the preceeding sequence of integers in \(\) or specifically: \(,t,>\). In the last entry of the above examples, we can see: \(<1,1,<0,2>,<0,j>>\) > \(<1,1,<0,1>,<0,h>>\) the sequences are identical until \(2 > 1\) in the 4th element. More examples follow, but the sequence \(\) will be ignored because it is well bounded and can be derived if required. 'Veblen Hierarchy Sequences' To illustrate sequences using the Veblen Hierarchy function, we will assume \( = <0,1>\) and focus on the behavior of \(q, , t, \) instead: These examples become difficult to follow at this point. Pseudo code is explained in the next section to explain how more complex ordinals can be constructed. 'Pseudo Code Algorithm' Following is pseudo code for an algorithm that can generate these ordinals and large numbers. Lets start with a general definition of the \(J_8\) function: \(J_8(,n,p) = f_g^n(p) = f_{(\lambda\uparrow\uparrow t)^{\gamma_e}.\gamma_c+\gamma_a}^n(p)\) where \( \gamma = (\lambda\uparrow\uparrow t)^{\gamma_e}.\gamma_c+\gamma_a\) and \(\lambda = \varphi(\gamma_{q})\) The pseudo code follows this logic: 1. Sequence \( = ,t,,,>\) where q is a finite integer 2. Sequence \( = <,,...,,p,m>)\) *when \(q > 1\) then \(\lambda = \varphi^m(\gamma_{p-1},\gamma_p,\gamma_{q-p})\) where **\(\delta_1 < \varphi(1, 0_{q})\) **WORK IN PROGRESS pseudo code for the case \(q > 1\) will be provided *when \(q = 1\) then \(\lambda = \varphi(1) = \omega\) *when \(q = 0\) then \(\lambda = \) null 3. t is a finite integer or null if \(q = 0\) 4. Sequence \(\) is recursively defined or null if \(q = 0\) and with *\(<0,0> < \) is Lower Bound *\( < ,min(2,t)>\) is Higher Bound 5. Sequence \(\) is recursively defined or null if \(q = 0\) and with *\(<0,0> < \) is Lower Bound *\( < ,t>\) is Higher Bound 6. Sequence \(\) is recursively defined or simply \(a\) (i.e. finite integer) if \(q = 0\) and with *\( < ,t,>\) is Higher Bound Category:Blog posts